[1] 101
March 4, 2024
R est un logiciel de développement scientifique spécialisé dans le calcul et l’analyse statistique
- les statuts, des liens, des références.
- <http://www.r-project.org/>
- binaires d’installation, packages, documentations, …
- <http://cran.r-project.org/>
La conférence des utilisateurs de R:
annuelle, prochaine édition à Toulouse
The R journal propose des articles sur
de nouvelles extensions, des applications, des actualités.
Les logiciels de développement scientifique sont spécialisés en
algèbre linéaire
Matlab de Mathworks, une référence,
Scilab de l’INRIA, l’alternative libre de matlab,
Octave de GNU, l’alternative open source ,
statistiques
SAS (SAS Inc.), la référence,
S-PLUS (TIBCO), le concurrent,
calcul symbolique
Mathematica (Wolfram), la référence,
Mapple (Maplesoft), la référence aussi,
Maxima (GNU), l’alternative open source .
Autres
Lorsque vous ouvrez RStudio pour la première fois, vous serez accueilli par trois panneaux:
Une fois que vous ouvrez des fichiers, tels que des scripts R, un panneau d’éditeur s’ouvre également en haut à gauche.
Il existe deux manières principales d’interagir avec R:
Ctrl-1 et Ctrl-2 qui vous permettent de sauter entre le script et les fenêtres de la console.
# signes pour commenter.Run situé au-dessus du panneau de l’éditeur,Run, vous pouvez utiliser le bouton suivant,La chose la plus simple que vous puissiez faire avec R est l’arithmétique:
Et R imprimera la réponse, avec un précédent “[1]”. Ne t’inquiète pas pour ça pour l’instant, nous l’expliquerons plus tard. Pour l’instant, considérez-le comme indiquant une sortie.
Comme bash, si vous tapez une commande incomplète, R vous attendra pour complèter l’entrée:
> 1 +
+
Chaque fois que vous appuyez sur Entrée et que la session R affiche un “+” au lieu d’un “>”, signifie qu’il attend que vous complétiez la commande. Si vous voulez annuler une commande que vous pouvez simplement appuyer sur “Esc” et RStudio vous rendra le “>” rapide.
Si vous utilisez R depuis la ligne de commande plutôt que depuis RStudio,
vous devez utiliser Ctrl + C au lieu deEsc pour annuler la commande. Ce s’applique également aux utilisateurs de Mac!
Annuler une commande n’est pas seulement utile pour tuer des commandes incomplètes:
vous pouvez aussi l’utiliser pour dire à R d’arrêter d’exécuter du code (par exemple si
en prenant beaucoup plus de temps que prévu, ou pour se débarrasser du code que vous êtes en train d’écrire.
Lorsque vous utilisez R comme calculatrice, l’ordre des opérations est le même que vous aurait appris à l’école.
De la plus haute à la plus basse préséance:
(, )^ ou **/*+-Utilisez des parenthèses pour regrouper les opérations afin de forcer l’ordre de évaluation si elle diffère du défaut, ou pour préciser ce que vous avoir l’intention
Cela peut devenir compliqué lorsque cela n’est pas nécessaire, mais clarifie vos intentions. Rappelez-vous que d’autres peuvent lire votre code ultérieurement.
Le texte après chaque ligne de code s’appelle un “commentaire”. Tout ce qui suit le symbole de hachage (ou octothorpe) “#” est ignoré par R lorsqu’il exécute du code.
Les nombres vraiment petits ou grands ont une notation scientifique:
Ce qui est un raccourci pour “multiplié par10 ^ XX”. Donc 2e-4 est un raccourci pour 2 * 10 ^ (- 4).
Vous pouvez aussi écrire des nombres en notation scientifique:
R a beaucoup de fonctions mathématiques intégrées. Pour appeler une fonction, nous tapons simplement son nom, suivi par des parenthèses ouvertes et fermantes. Tout ce que nous tapons à l’intérieur des parenthèses s’appelle la fonction arguments:
Ne vous souciez pas d’essayer de vous souvenir de toutes les fonctions de R:
C’est un avantage que RStudio sur R , il dispose de capacités d’auto-complétion qui vous permettent plus facilement rechercher des fonctions, leurs arguments et les valeurs qu’ils prendre.
Taper un ? Avant le nom d’une commande ouvrira la page d’aide pour cette commande. En plus de fournir
Nous pouvons également faire la comparaison en R:
== pour comparer deux nombres à moins qu’ils ne soient entiers (un type de données pouvant représenter spécifiquement uniquement des nombres entiers).all.equal.Stocker des valeurs dans des variables en utilisant l’opérateur d’affectation <-
Plus précisément, la valeur stockée est une approximation * décimale * de cette fraction appelée [nombre à virgule flottante] (http://en.wikipedia.org/wiki/Floating_point).
Recherchez l’onglet Environment dans l’un des volets de RStudio, et vous verrez que x et sa valeur est apparu. Notre variable x peut être utilisée à la place d’un nombre dans tout calcul qui attend un nombre:
Notez également que les variables peuvent être réaffectées:
x contenait la valeur 0.025 et a maintenant la valeur 100.
Les valeurs d’affectation peuvent contenir la variable affectée à:
Le côté droit de l’affectation peut être toute expression R valide. Le côté droit est entièrement évalué avant que l’affectation ait lieu.
Les noms de variables peuvent contenir des lettres, des chiffres, des traits de soulignement et des points. Ils ne peut pas commencer avec un nombre ni contenir des espaces du tout. Différentes personnes utilisent différentes conventions pour les noms de variables longues, celles-ci comprennent
Ce que vous utilisez dépend de vous, mais soyez cohérent.
Il est également possible d’utiliser l’opérateur = pour l’affectation:
Mais c’est beaucoup moins courant parmi les utilisateurs de R.
Donc, la recommandation est d’utiliser <-.
Il existe quelques commandes utiles que vous pouvez utiliser pour interagir avec la session R.
ls listera toutes les variables et fonctions stockées dans l’environnement global (votre session de travail):
Comme dans le shell, ls cachera toutes les variables ou fonctions commençant avec un “.” par défaut.
Pour lister tous les objets, tapez ls (all.names = TRUE)
Notez ici que nous n’avons donné aucun argument à ls, mais nous avons quand même nécessaire de donner aux parenthèses de dire à R d’appeler la fonction.
Si vous tapez ls par lui-même, R imprimera le code source de cette fonction!
function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE,
pattern, sorted = TRUE)
{
if (!missing(name)) {
pos <- tryCatch(name, error = function(e) e)
if (inherits(pos, "error")) {
name <- substitute(name)
if (!is.character(name))
name <- deparse(name)
warning(gettextf("%s converted to character string",
sQuote(name)), domain = NA)
pos <- name
}
}
all.names <- .Internal(ls(envir, all.names, sorted))
if (!missing(pattern)) {
if ((ll <- length(grep("[", pattern, fixed = TRUE))) &&
ll != length(grep("]", pattern, fixed = TRUE))) {
if (pattern == "[") {
pattern <- "\\["
warning("replaced regular expression pattern '[' by '\\\\['")
}
else if (length(grep("[^\\\\]\\[<-", pattern))) {
pattern <- sub("\\[<-", "\\\\\\[<-", pattern)
warning("replaced '[<-' by '\\\\[<-' in regular expression pattern")
}
}
grep(pattern, all.names, value = TRUE)
}
else all.names
}
<bytecode: 0x7f84fabd2ce8>
<environment: namespace:base>
Vous pouvez utiliser rm pour supprimer des objets dont vous n’avez plus besoin:
Si vous avez beaucoup de choses dans votre environnement et souhaitez les supprimer toutes, vous pouvez transmettre les résultats de ls à la fonction rm:
rm(list=ls())
Dans ce cas, nous avons spécifié que les résultats de ls devraient être utilisés pour le L’argument list dans rm. Lorsque vous attribuez des valeurs aux arguments par nom, vous devez utilisez l’opérateur = !!
Si au lieu de cela nous utilisons <-, il y aura des effets secondaires inattendus, ou vous pourriez avoir un message d’erreur:
Error in rm(list <- ls()): ... must contain names or character strings
Il est possible d’ajouter des fonctions à R en écrivant un paquet, ou par obtenir un paquet écrit par quelqu’un d’autre. Au moment de l’écriture, il y a sont plus de 7 000 paquets disponibles sur CRAN (l’archive complète de R réseau). R et RStudio ont des fonctionnalités pour gérer les paquets:
installed.packages ()
install.packages (" packagename "), où packagename est le nom du package, entre guillemets.
Vous pouvez mettre à jour les paquets installés en tapant update.packages ()
Vous pouvez supprimer un paquet avec remove.packages (" packagename ")
Vous pouvez rendre un paquet disponible pour être utilisé avec library (packagename)
R, et chaque paquet, fournissent des fichiers d’aide pour les fonctions. Pour chercher de l’aide sur un fonction d’une fonction spécifique qui est dans un package chargé
Cela chargera une page d’aide dans RStudio (ou du texte brut dans R seul).
Pour demander de l’aide sur des opérateurs spéciaux, utilisez des guillemets:
De nombreux paquets contiennent des “vignettes”: des tutoriels et des exemples de documentation. Sans aucun argument, vignette() listera toutes les vignettes pour tous les paquets installés;
vignette (package =" nom-du-paquet ")
listera toutes les vignettes disponibles pour
package-name et vignette ("vignette-name")
ouvriront la vignette spécifiée.
Si un paquet ne contient aucune vignette, vous pouvez généralement trouver de l’aide en tapant
help("nom-du-paquet").
Si vous ne savez pas exactement dans quel paquet est une fonction ou comment elle est spécifiquement orthographiée, vous pouvez effectuer une recherche floue:
knitrAn article about computational science in a scientific publication is not the scholarship itself, it is merely advertising of the scholarship. The actual scholarship is the complete software development environment and the complete set of instructions which generated the figures.
knitrpour générer des rapports qui combinent le texte, le code et les résultats.
pour mettre en forme le texte
Markdown est un langage de balisage léger créé par John Gruber en 2004. Son but est d’offrir une syntaxe facile à lire et à écrire. Un document balisé par Markdown peut être lu en l’état sans donner l’impression d’avoir été balisé ou formaté par des instructions particulières. — Wikipedia
code dans des blocs délimités par des guillemets triples suivis de {r}.
Rmardown est un univers extensible, si vous voulez continuez, lisez
https://rmarkdown.rstudio.com/
knitrTools -> Install Packages
Dans R Studio, cliquez sur Fichier → Nouveau fichier → R Markdown et vous obtiendrez une boîte de dialogue du type
Vous créez un fichier avec une entête dite yaml du type
---
title: "Initial R Markdown document"
author: "Karl Broman"
date: "April 23, 2015"
output: html_document
---qui précise comment peut être transformé le fichier
Markdown est un langage à balise
**gras**,_italics_.Vous pouvez créer une liste à puces en écrivant une liste avec des tirets ou astérisques, comme ceci:
* gras avec double astérisque
* italiques avec des soulignés
* police de type code avec backticks
ou comme ça:
- gras avec double astérisque
- italiques avec des soulignés
- police de type code avec backticks
Vous pouvez créer une liste numérotée en utilisant simplement des chiffres. Vous pouvez utiliser le même nombre encore et encore si vous voulez:
1. gras avec double astérisque
1. italiques avec des soulignés
1. police de type code avec backticks
Cela apparaîtra comme:
Vous pouvez créer des en-têtes de section de différentes tailles en initiant une ligne avec un certain nombre de symboles #:
# Titre
## Section principale
### Sous-section
#### Sous-sous-section
Vous compilez le document R Markdown en cliquant sur le “Knit HTML” en haut à gauche.
[texte à afficher] (http://the-web-page.com).

Vous pouvez faire des indices (par exemple, F2) avec F~2~ et des exposants (par exemple, F2 ) avec F^2^.
Si vous savez écrire des équations dans [LaTeX] (http://www.latex-project.org/), vous serez heureux de savoir que vous pouvez utiliser $ $ et $$ $$ pour insérer des équations mathématiques, comme $E = mc^2$ E = mc^2 et
$$y = \mu + \sum_ {i = 1}^p \beta_i x_i + \epsilon$$
y = \mu + \sum_ {i = 1}^p \beta_i x_i + \epsilon
Markdown est intéressant et utile, mais le plus grand intérêt vient du mélange du texte balisé avec des morceaux de code R.
Les morceaux de code ressemblent à ceci:
```{r load_data}
gapminder <- read.csv("~/Desktop/gapminder.csv")
```
C’est une bonne idée de donner chaque morceau un nom, car ils vous aideront à corriger les erreurs et, si des graphiques sont produit, les noms de fichiers sont basés sur le nom du bloc de code les a produites.
Lorsque vous appuyez sur le bouton “Knit HTML”, le document R Markdown est traité par [knitr] (http://yihui.name/knitr) et un simple Markdown document est produit (ainsi que, potentiellement, un ensemble de fichiers de figure): le code R est exécuté et remplacé à la fois par l’entrée et la sortie; si les chiffres sont produits, des liens vers ces chiffres sont inclus.
Les documents Markdown et figure sont ensuite traités par l’outil pandoc, qui convertit le fichier Markdown en fichier fichier html, avec les chiffres incorporés.
Il y a une variété d’options pour affecter la façon dont les morceaux de code sont traités.
echo = FALSE pour éviter que le code lui-même ne soit affiché.results ="hide" pour éviter d’imprimer des résultats.eval = FALSE pour que le code soit affiché mais pas évalué.warning = FALSE et message = FALSE pour masquer les avertissements ou messages produits.fig.height et fig.width pour contrôler la taille des figures produit (en pouces).[1] "numeric"
::: :::
[1] "character"
::: :::
[1] "logical"
::: :::
C'est l'opération qui consiste à *attribuer une valeur* à une variable.
En R, plusieurs choix sont possibles:
<- (signe inférieur suivi du signe moins)[1] "l'indien"
= peut être utilisé la plupart du temps[1] 3
assign permet cette opération (d’où l’anglicisme assignation)NA est le code R pour les valeurs manquantes (absentes des données),NaN est le code de R pour signifier un résultat numérique aberrant ,Inf et -Inf sont les valeurs réservées pour plus et moins \infty,NULL est l’objet nul.[1] 4 2 NA 5
[1] NaN
[1] Inf
NULL
Les opérations sur les vecteurs s’effectuent terme-à-terme
Soient x,y tels que ::: {.cell}
:::
+addition des éléments de deux vecteurs
[1] -4 -4 6 -4
-soustraction des éléments de deux vecteurs
[1] 6 8 -12 -4
*multiplication des éléments de deux vecteurs ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] -5 -12 -27 0
::: :::
\division des éléments de deux vecteurs ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] -0.2000000 -0.3333333 -0.3333333 -Inf
::: :::
Lors d’une opération entre vecteurs, les vecteurs trop courts sont ajustés pour atteindre la taille du plus grand vecteur en recyclant les données.
\rightsquigarrow souvent pratique mais attention aux effets de bords!
floor,ceiling,round ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] 0
:::
[1] 1
[1] 0.667
:::
` \^{},\%\%,\%/\%,abs,log,exp,log10,sqrt,cos,tan,sin...`
s’appliquent toutes . ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] 1 2 3
:::
[1] 1 1
:::
prod, sum, max, min, range, which.min, which.max, length
[1] -36
[1] -3.5
[1] 3
[1] 3
[1] -8
[1] -8 3
[1] 3
[1] 1
Pour le minimum / maximum terme-à-terme: pmin,pmax.
`cumsum, cumprod, cummin, cummax`
[1] -2 -2 6 12
[1] -2 -1 -4 -2
[1] -2 1 1 2
[1] -2 -2 -3 -3
Fonctionnent pour tous les modes
unique,intersect,union,setdiff,setequal,is.element
[1] "banane" "citron"
[1] "banane"
[1] "banane" "citron" "orange"
[1] FALSE
[1] FALSE
Il existe de nombreuse manière de générer des vecteur de manière plus ou moins automatique
R étant un langage vectoriel savoir générer le vecteur que l’on veut représente un atout important pour programmer en R
:from:to
Génère une séquence par pas de un depuis le nombre `from`
jusqu'à `to` (si possible).
[1] -5 -4 -3 -2 -1 0 1 2 3 4 5
[1] 5 4 3 2 1 0 -1 -2 -3 -4 -5
[1] 3.141593 4.141593 5.141593
[1] 0.5 1.0 1.5 2.0 2.5 3.0
[1] 1 2 3
seqseq(from,to)seq(from,to,by=)seq(from,to,length.out=) [1] 1 2 3 4 5 6 7 8 9 10
[1] 2 4 6 8 10
[1] 2.0 3.6 5.2 6.8 8.4 10.0
reprep(x,times), où times peut être un vecteur,rep(x,each).[1] 1 1 1
[1] "Mercy" "Mercy" "Mercy"
[1] "A" "A" "A" "B" "B" "C" "C" "C" "C"
[1] TRUE TRUE FALSE FALSE
'<', '<=', '>', '>=', '==' '!=''\&' (intersection), '|' (union), '!' (négation), xor.[1] FALSE FALSE TRUE FALSE FALSE TRUE
[1] 2
[1] 0
'c()'L'opérateur `'c()'` peut s'appliquer à n'importe quoi pourvu que
l'on concatène des vecteurs de même type.
[1] 1 2 3 4
[1] -3.14 -1.05 1.05 3.14 1.00 1.00 2.00 2.00 3.00 3.00 0.00
Dans le second exemple, les entiers composants c(1:3) ont été forcés au typage flottant.
pasteConcaténation de chaînes de caractères. Convertit en caractères
les éléments passés en argument avant toute opération.
[1] "R c'est bien"
[1] "2 ieme" "3 ieme" "4 ieme"
[1] "A1" "A2" "A3" "A4" "A5"
[1] "A1A2A3A4A5"
x.x[subset].subset peut prendre 4 types différentsx;x à conserver.Vecteurs logiques
[1] 3 6 9 NA
[1] 3.0 6.0 -2.0 9.0 -0.5
[1] 3 6 9
[1] 3.1
[1] 3.0 -2.0 NA -0.5
Vecteurs aux composantes positives ou négatives
[1] 3.0 6.0 -2.0 9.0 NA -0.5
[1] 6
[1] 3 6 -2 9 NA
[1] 6.0 -2.0 9.0 -0.5
[1] -0.5
Vecteurs de chaînes de caractères
var1 var2 var3 var4 var5 var6
3.0 6.0 -2.0 9.0 NA -0.5
var1 var3
3 -2
- `sort` renvoie le vecteur classé par ordre croissant ou
décroissant,
- `order` renvoie les indices d'ordre des éléments par ordre
croissant ou décroissant,
- `which` renvoie les indices de `x` vérifiant une
condition;
- `sample` échantillonne aléatoirement dans un vecteur
`x`, avec ou sans remise.
[1] -5 -4 -3 -2 -1 0 1 2 3 4 5
[1] 8 5 11 4 1 10 2 9 3 7 6
[1] -5 -4 -3 -2 -1 0 1 2 3 4 5
[1] 5 4 3 2 1 0 -1 -2 -3 -4 -5
[1] 1 4
Un facteur est un vecteur de variables catégorielles .
Les niveaux du facteur peuvent être ordonnés ou pas.
catégoriser les données d’un vecteur (ce qui s’avère très utile pour la gestion des variables qualitatives).
\rightsquigarrow un facteur est souvent associé à d’autres vecteurs pour en définir une partition.
factor [1] 1 2 1 2 2 2 3 1 1 3
Levels: 1 2 3
[1] 1 1 2 2 2 2 1 2 3 2
Levels: 1 2 3 4 5
nlevels,levels,table3 niveaux: CR MdC thésard
x
CR MdC thésard
1 10 4
Un exemple de facteur associé à un vecteur
Chacun me donne son âge et son grade^[sauf un qui refuse :'( ]
grd
CR MdC thd
3 5 7
tapplyUn autre point fort de R
Applique une fonction sur un vecteur partitionné en groupes.
CR MdC thd
33.66667 31.50000 27.85714
CR MdC thd
3.214550 6.191392 2.794553
Les matrices et tableaux sont la des structure de stockage très courantes
arrayUn tableau est un vecteur muni d'un attribut dimension (`dim`),
lui même défini par un vecteur. Il est défini par la commande
`array(data,dim,dimnames=)`
, , 1
[,1] [,2]
[1,] 1 3
[2,] 2 4
, , 2
[,1] [,2]
[1,] 5 7
[2,] 6 8
matrixUne matrice est un tableau à deux dimensions. Elle est définie par la commande
`matrix(data,nrow=,ncol=,byrow)`
En conséquence
array à deux dimensions est automatiquement converti en matrixmatrix[1] "matrix" "array"
[1] "matrix" "array"
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
Étant donné qu’une matrice est un vecteur pourvu d’une dimension, on a la proposition suivante:
**La plupart des opérateurs vectorielles s'appliquent**
(arithmétiques/mathématiques, ensemblistes, d'indexation).
4 0 0
[1] 3 5 7 9
[1] 2 6 7 10
[1] 4 8 6 2 1 7 3 9 5
[,1] [,2] [,3]
[1,] 1.0000 0.0183 2.7183
[2,] 0.3679 54.5982 0.0498
[3,] 7.3891 0.1353 20.0855
+,/,*,\^{} sont les opérateurs usuels terme-à-terme,\%*\% est le produit matriciel,crossprod() est le produit scalaire,t() transpose une matrice,diag() extrait / spécifie la diagonale.[1] -1 -2 1
[1] 1 1 1
[,1] [,2] [,3]
[1,] 22 -7 5
[2,] -8 20 -4
[3,] 2 2 3
c() concatène les éléments de plusieurs matrices en un vecteur,cbind() empile horizontalement plusieurs matrices,rbind() empile verticalement plusieurs matrices. [1] 1 1 1 1 1 1 2 2 2 2 2 2
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 1 2 2 2
[2,] 1 1 1 2 2 2
[,1] [,2] [,3]
[1,] 1 1 1
[2,] 1 1 1
[3,] 2 2 2
[4,] 2 2 2
La commande `solve` résout
\mathbf{A} x = \mathbf{b},
[1] 1.0714286 -0.2857143
ou inverse une matrice:
[,1] [,2]
[1,] 1 0
[2,] 0 1
Utile pour l’analyse numérique
R dispose des outils classiques d’algèbre linéaire
det: calcule le déterminant d’une matrice;chol: factorisation de Cholesky ( A = C^t C, avec A symétrique, C triangulaire supérieure);qr: factorisation QR (A = Q R avec Q orthogonale, R triangulaire supérieure);eigen: calcule valeurs propres et vecteurs propres d’une matrice;svd: calcule la décomposition en valeurs singulières.listUne liste est une **collection d'objets hétérogènes**. Elle
est définie par la commande `list(el1=, el2=, ...)`. Les
éléments d'une liste peuvent posséder un nom.
[[1]]
[1] 1 2 3
[[2]]
[1] "robert" "johnson"
[[3]]
[,1] [,2]
[1,] -0.3011248 -0.3927275
[2,] -0.8763680 -0.9122887
$numero
[1] 1 2 3
$noms
[1] "robert" "johnson"
$mat
[,1] [,2]
[1,] -0.3204240 -0.3226773
[2,] 0.1843568 -0.6909763
nom_liste[[i]] uniquement.nom_liste$nom_elt.[1] "robert" "johnson"
[1] "johnson"
[1] "robert" "johnson"
[1] "johnson"
[containsverbatim,allowframebreaks] ## Manipulation de listes
Fonctionne (presque) comme pour les vecteurs
[1] 1 2
lapplyApplique une fonction à chaque élément d'une liste
$numero
[1] 3
$noms
[1] 2
$mat
[1] 4
c()Permet de concaténer deux listes.
[[1]]
[1] 1 2
[[2]]
[1] "a" "c" "g" "t"
[[3]]
[1] -0.2785331 -0.4804855 -0.5890904
[[4]]
[1] "yop"
Un autre point fort de R
data.frameC'est une liste à laquelle on impose certaines
contraintes^[que je vous épargne], afin de rassembler
vecteurs et facteurs sous la forme d'un tableau de données.
On peut spécifier le nom des colonnes par le vecteur `row.names`
ou directement comme pour une liste:
`data.frame(e1=,e2=, ...,row.names=)`
age grade sexe
1 25 thd F
2 35 CR F
3 32 MdC F
4 27 thd F
5 32 thd F
6 40 MdC F
attach() detach placent ôtent les éléments du tableaux de données dans l’itinéraire de recherche. [1] 25 35 32 27 32 40 26 25 26 28 30 NA 36 30 30
[1] "thd" "CR" "MdC" "thd" "thd" "MdC" "MdC" "thd" "thd" "MdC" "CR" "MdC"
[13] "CR" "thd" "thd"
tapply (ou by) age grade sexe
Min. :25.00 Length:15 F:12
1st Qu.:26.25 Class :character M: 3
Median :30.00 Mode :character
Mean :30.14
3rd Qu.:32.00
Max. :40.00
NA's :1
sexe: F
[1] 30.66667
------------------------------------------------------------
sexe: M
[1] 27
grade: CR
[1] 33.66667
------------------------------------------------------------
grade: MdC
[1] 31.5
------------------------------------------------------------
grade: thd
[1] 27.85714
Les structure de contrôle sont les blocs d’un programme
{expr_1; expr_2; …; expr_n }
ou
{
expr_1 …
expr_n
}
if,if/else,ifelsecondition est une valeur logique: penser à \&,|,!, …else est optionnel,elseif permet d’imbriquer les conditionnements.forfor (var in set) { expr(var) }
ou
for (var in set) expr(var)
à fuir pour éviter les effets de bords sournois!
forvar est la variable incrémentée,set est un vecteur définissant les valeurs successives,while etrepeat`while (condition) { expr
}
ou
repeat { expr }
for, éviter les imbrications sources de lenteur.break, nextrepeat { expr if (condition) {break} }
ou
while (condition1){ expr_1 if (condition2) {next} expr_2
}
break est la seule manière d’interrompre une boucle repeat.Permettent de factoriser des lignes de codes
nom_de_la_fonction <- function(arg1,arg2, …) { expression
return(var) }
return peut être omis (à éviter): dans ce cas la dernière valeur calculée est renvoyée.functions.R, chargé par source.Avec suppression des valeurs manquantes !
[1] 0.0999334
[1] 1.925
Encore un point fort de R
- les arguments peuvent être passés dans le
**désordre** s'ils sont **nommés**: `var=object`,
- on peut définir une valeur par défaut pour n'importe
quel argument lors de la définition de la fonction: `var=10`.
- en cas de **sorties multiples**, les sorties doivent être
renvoyées sous forme de liste.
[1] 0.8118145
Moyenne: 1.676369 et variance: 2.287758
Les packages sont des codes qui peuvent être inclus pour étendre les fonctionnalités de R
An article about computational science in a scientific publication is not the scholarship itself, it is merely advertising of the scholarship. The actual scholarship is the complete software development environment and the complete set of instructions which generated the figures.
Par exemple, `SIMoNe` : construire un graphe des interactions
significatives entre gènes à partir de données du transcriptome.
inferGraph(data))Livre d’économie publié en 2013 et écrit par Thomas Piketty, paru aux éditions du Seuil
Bestseller aux états unis
Le capital au 21ème siècle
les inégalités de revenu, les inégalités de patrimoine et le rapport capital/revenu dans les pays développés suivent chacun une courbe en U
on retrouve au début du xxie siècle des niveaux d’inégalités comparables aux niveaux d’inégalités du xixe siècle et du début du xxe siècle.
Si l’on se concentre sur le revenu des personnes appartenant à des ménages fiscaux
A partir des impôts on peut accéder revenu de chaque ménage du pays avant et après impôt.
L’INSEE utilise une mesure du revenu par unité de consommation, à l’aide d’une échelle d’équivalence. L’échelle la plus utilisée actuellement consiste à décompter
1 unité de consommation (UC) pour le premier adulte du ménage,
0,5 UC pour les autres personnes de 14 ans ou plus,
0,3 UC pour les enfants de moins de 14 ans.
Les pays du monde s’ordonnent ainsi entre 0,25 (pays d’Europe scandinave et centrale) et 0,70 (pays émergents d’Amérique latine, d’Afrique centrale)
Si x_i est la richesse ou le revenu de la personne i, et qu’il y a n personnes, alors le coefficient de Gini G est donné par :
G = \frac{\sum_{i=1}^{n}\sum_{j=1}^{n} |x_i - x_j|}{2\sum_{i=1}^{n}\sum_{j=1}^{n} x_j} = \frac{\sum_{i=1}^{n}\sum_{j=1}^{n} |x_i - x_j|}{2n\sum_{j=1}^{n} x_j} = \frac{\sum_{i=1}^{n}\sum_{j=1}^{n} |x_i - x_j|}{2n^2\bar{x}}
Coefficient de Gini
G=2A = 1-2B
Revenu en France en 2011
Evolution du coefficient de Gini en France
Coefficient de Gini dans le monde
Activité qui consiste dans le recueil, le traitement et l’interprétation de données d’observation issues d’une population:
Chaque individu est décrit par un ensemble de variables:
qualitative (sexe, nationalité, état matrimonial, ...): les valeurs prises par le caractère sont les modalités
quantitative (taille, poids, …)
Étude exhaustive Dite par recensement. L’étude d’une population de grande taille est souvent difficile voire impossible
Échantillon. Le processus de sélection d’un échantillon est l’échantillonnage. Seule solution d’une le cas d’une population infinie
Processus visant à
X = (x_i^j)=\left( \begin{matrix} x^1_1 & & x^j_1 & & x^p_1 \\ & & . & & . \\ x^1_i & & x^j_i & & x^p_i \\ & & . & & . \\ x^1_n & & x^j_n & & x^p_n \end{matrix} \right)
\boldsymbol X=(X^1,\dots,X^p)'
Détecter la Dépendance entre paires de variables
Nous considérerons dans un premier temps une seule colonne du tableau de données, soient n observations: x_1, ... , x_n
La variable prend ses valeurs dans V_x =\{ \epsilon_1,...,\epsilon_K \} avec \epsilon_1 < ... < \epsilon_K
Couplés à la commande table Le diagramme en barres et le graphe en camembert permettent de visualiser le découpage d’une population en donnée catégorielle. ::: {.cell} ::: {.cell-output .cell-output-stdout}
pop pepin.08 poids.08 volcm3.08
1 CE 1.0 0.89 7.70
2 CE 1.0 1.14 8.82
3 CE 1.2 1.26 10.20
4 CE 1.2 0.66 NA
5 CE 1.2 0.83 NA
6 CE 1.3 0.54 4.61
::: :::
Camembert des différentes populations
Moyenne: \bar{x}=\frac{1}{n} \sum_{i=1}^n x_i
Remarque: la somme des écarts à la moyenne empirique est nulle \sum_i (x_i -\bar{x}) = 0
Inconvénient : problème des valeurs aberrantes
Moyenne tronquée: M_k = \frac{1}{n-2k} \sum_{i=k+1}^{n-k} x_{(i)} où x_{(i)} est l’observation de rang i
Médiane: M = \begin{cases} x_{(n/2)} \mbox{ si $n$ est pair,}\\ x_{ (\lfloor n/2 \rfloor +1)} \mbox{ sinon} \end{cases}
Fractile empirique d’ordre \alpha \hat{f}_\alpha = \begin{cases} x_{(n \alpha)} \mbox{ si $n\alpha$ est entier,}\\ x_{ (\lfloor n \alpha \rfloor +1)} \mbox{ sinon} \end{cases}
Le résumé numérique s’adapte selon la nature des variables (univariée, multivariée, factorielle)
Min. 1st Qu. Median Mean 3rd Qu. Max. NA's
0.000 1.400 1.800 1.858 2.400 3.200 27
CE CO TE
84 89 72
| pop | pepin.08 | poids.08 | volcm3.08 | |
|---|---|---|---|---|
| CE:84 | Min. :0.000 | Min. :0.390 | Min. : 3.44 | |
| CO:89 | 1st Qu.:1.400 | 1st Qu.:0.820 | 1st Qu.: 7.14 | |
| TE:72 | Median :1.800 | Median :1.060 | Median : 8.91 | |
| NA | Mean :1.858 | Mean :1.212 | Mean :10.47 | |
| NA | 3rd Qu.:2.400 | 3rd Qu.:1.360 | 3rd Qu.:11.90 | |
| NA | Max. :3.200 | Max. :3.750 | Max. :33.80 | |
| NA | NA’s :27 | NA’s :28 | NA’s :44 |
Package Hmiscvigne
4 Variables 245 Observations
--------------------------------------------------------------------------------
pop
n missing distinct
245 0 3
Value CE CO TE
Frequency 84 89 72
Proportion 0.343 0.363 0.294
--------------------------------------------------------------------------------
pepin.08
n missing distinct Info Mean Gmd .05 .10
218 27 26 0.997 1.858 0.753 1.0 1.2
.25 .50 .75 .90 .95
1.4 1.8 2.4 2.7 2.9
lowest : 0 0.5 0.8 1 1.1, highest: 2.8 2.9 3 3.1 3.2
--------------------------------------------------------------------------------
poids.08
n missing distinct Info Mean Gmd .05 .10
217 28 122 1 1.212 0.6078 0.578 0.676
.25 .50 .75 .90 .95
0.820 1.060 1.360 1.868 2.472
lowest : 0.39 0.4 0.41 0.42 0.49, highest: 3.31 3.39 3.43 3.47 3.75
--------------------------------------------------------------------------------
volcm3.08
n missing distinct Info Mean Gmd .05 .10
201 44 188 1 10.47 5.306 4.71 5.98
.25 .50 .75 .90 .95
7.14 8.91 11.90 16.58 23.06
lowest : 3.44 3.48 3.97 4.13 4.32 , highest: 26.97 27.59 28.29 28.54 33.8
--------------------------------------------------------------------------------
Dans le cas où la variable x est continue, la réalisation d’un tableau de fréquence nécessite un partitionnement préalable du domaine de définition en K classes de largeur
\hat{F}: \mathbb{R} \mapsto [0,1], \ x \mapsto \frac{1}{n} card\{i: x_i \leq x \}
Un graphe en tige est feuille permet de visualiser le tableau des fréquences
The decimal point is 1 digit(s) to the left of the |
0 | 00000000
2 |
4 | 0
6 |
8 | 0
10 | 00000000000
12 | 0000000000000000000
14 | 00000000000000000000000000000000000000
16 | 000000000000000000000
18 | 0000000000000000000000
20 | 000000000000000000000
22 | 000000000000000000
24 | 000000000000000000000
26 | 0000000000000000000
28 | 00000000
30 | 000
32 | 0000000
Crée un objet qui peut être tracé avec .
F.d.r empirique du poids pour les non TE et les TE
Pour comparer visuellemnt deux distributions, la manière la plus efficace est le graphe quantile/quantile (qui doivent correspondre si les distributions sont proches.)
qqplot des distributions de poids de CE et CO
qqplot des distributions de poids de CE et CO
Estimateur de la fonction de densité \hat{f}_n(x) = \sum_i h_i {\mathbb I}_{[a_i ,a_{i+1}[}(x) \ \ a_1 < ... < a_{k+1}
Découpage en intervalles
Calcul de la fréquence
Aire du rectangle proportionnel à la fréquence \sum_i h_i(a_{i+1}-a_i)=1 \mbox{ et } h_i(a_{i+1}-a_i) = \hat{P}_F (X \in [ a_i, a_{i+1}[)
Attention : hauteur proportionnelle à la fréquence si et seulement si les intervalles ont tous la même largeur
Nombre d’intervalles :
histogramme du nombre de pépins par baie en 2008
La boîte à moustache permet de visualiser les grands traits caractéristiques d’une distribution.
boîtes à moustaches du poids selon les populations
Missing rows: 4, 5, 11, 19, 20, 21, 49, 71, 78, 79, 80, 81, 82, 83, 84, 99, 112, 129, 139, 152, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 180, 181, 188, 203, 240, 241, 242, 243, 244, 245
Mise en évidence de certaines caractéristiques :
histy<-function(x,y){
mycolors<-colors()[seq(2,600,by=10)]
hist(x,plot=FALSE)$breaks->breaks
length(levels(y))->nbLevels
z<-matrix(0,nbLevels,length(breaks)-1)
for (l in 1:nbLevels){
xl<-x[as.numeric(y)==l]
inter<-matrix(c(breaks[-length(breaks)],breaks[-1]),ncol=2)
apply(inter,1,function(interi) sum((interi[1]<xl) & (xl<=interi[2]))) -> z[l,]
}
as.table(z)->z
dimnames(z)[2]<-list(apply(inter,1,function(x) toString(paste(x[1],x[2],sep="-"))))
dimnames(z)[1]<-list(levels(y))
barplot(z,col=mycolors[2:(nbLevels+2)])
legend("topright",levels(y),fill= mycolors[2:(nbLevels+2)])
invisible(z)
}
par(mfrow=c(2,2))
histy(iris$Petal.Length,iris$Species)
histy(iris$Petal.Width,iris$Species)
histy(iris$Sepal.Length,iris$Species)
histy(iris$Sepal.Width,iris$Species) Rappels
X réalisation d’un échantillon de taille n du vecteur aléatoire \bX
\boldsymbol x_i réalisation de taille 1 de \boldsymbol X
\boldsymbol x^j réalisation d’un échantillon de taille n de \boldsymbol X^j
Moyenne empirique \overline{\boldsymbol x}=(\overline{x}^1,\ldots,\overline{x}^p)' \hspace{0.5cm} \mbox{où}\hspace{0.5cm} \overline{x}^j=\frac{1}{n}\sum_{i=1}^n x_i^j
Variance empirique s^2_j =\frac{1}{n} \sum_{i=1}^n (x^j_i- \overline{x}^j)^2
Covariance empirique s_{jj'} =\frac{1}{n} \sum_{i=1}^n (x^j_i- \overline{x^j}).(x^j_i- \overline{x^{j'}})
Corrélation empirique r_{jj'} = \frac{s_{jj'}}{s_j s_{j'}}
S=(s_{jj'}) =\frac{1}{n} (X-1_n \overline{\boldsymbol x})'(X-1_n \overline{\boldsymbol x} ) = \frac{1}{n} Y'Y où 1_n est la matrice de dimension (n,1) remplie de 1 et Y est la matrice centrée associée à X.
| Sepal.Length | Sepal.Width | Petal.Length | Petal.Width | |
|---|---|---|---|---|
| Sepal.Length | 0.6856935 | -0.0424340 | 1.2743154 | 0.5162707 |
| Sepal.Width | -0.0424340 | 0.1899794 | -0.3296564 | -0.1216394 |
| Petal.Length | 1.2743154 | -0.3296564 | 3.1162779 | 1.2956094 |
| Petal.Width | 0.5162707 | -0.1216394 | 1.2956094 | 0.5810063 |
| Sepal.Length | Sepal.Width | Petal.Length | Petal.Width | |
|---|---|---|---|---|
| Sepal.Length | 0.6856935 | -0.0424340 | 1.2743154 | 0.5162707 |
| Sepal.Width | -0.0424340 | 0.1899794 | -0.3296564 | -0.1216394 |
| Petal.Length | 1.2743154 | -0.3296564 | 3.1162779 | 1.2956094 |
| Petal.Width | 0.5162707 | -0.1216394 | 1.2956094 | 0.5810063 |
Dans \mathbb R - Pts uniformément répartis dans [-1,+1] - % de points situées à 1 distance \leq 0.75 de l’origine : 75 \%
Dans \mathbb R^{10} - Pts uniformément répartis dans [-1,+1]^{10} - % de points situées à 1 distance \leq 0.75 de l’origine : 5 \%
on veut construire un histogramme en s’appuyant sur au moins une moyenne de 10 points par intervalle et 10 classes par variable
\mathbb R : 10 classes n=100
\mathbb R^2 : 100 classes n=1000
\mathbb R^{10} : 10^{10} classes n=10^{11}=100 milliards
Si p assez grand, l’espace \mathbb R^p est pratiquement vide et sauf si les données se situent au voisinage d’une variété de faible dimension, l’analyse des données n’apportera aucune information intéressante.
Les points voisins d’un point donné sont tous très loin : difficultés dans l’emploi de méthodes du type k-plus proches voisins
Soit un échantillon où chaque individu est caractérisé par deux variables discrète X et Y distribuées suivant des loi multinomiales à respectivement p et q modalités: ((X_1,Y_1),(X_2,Y_2), ... (X_n,Y_n))
Ce type d’échantillon est classiquement représenté par un tableau binaire T à
où
T_{ij} = \begin{cases} 1, \text{ si l'individu i possède la modalité j},\\ 0, \text{sinon.} \end{cases}
En poursuivant avec l’exemple des couleurs de cheveux et d’yeux. Si
| mar. | bleu | vert | nois. | noir | brun | … | |
|---|---|---|---|---|---|---|---|
| Individu 1 | 1 | 0 | 0 | 0 | 0 | 1 | … |
| Individu 2 | 0 | 1 | 0 | 0 | 0 | 1 | … |
| … | … | … | … | … | … | … | … |
| Individu n | 0 | 0 | 1 | 0 | 1 | 0 | … |
Ce type de tableau peut se représenter sous la forme d’un
à
Chaque case du tableau de contingence compte le nombre d’individus possédant la modilité i de la variable X et j de la variable Y: n_{ij}
| m_1 | m_2 | … | m_q | |
|---|---|---|---|---|
| l_1 | n_{11} | n_{12} | … | n_{1q} |
| l_2 | n_{21} | n_{22} | … | n_{2q} |
| … | … | … | … | … |
| l_p | n_{p1} | n_{p2} | … | n_{pq} |
A ce tableau on peut rajouter une ligne et une colonne contenant les marges
Le nombre total d’individus de l’échantillon est bien sûr
n=\sum_{ij} n_{ij} = \sum_i n_{i\bullet}= \sum_j n_{\bullet j}
Pour obtenir un tableau de contingence en R, il suffit d’utiliser l’instruction table:
Y
X Black Blond Brown Red
Blue 10 12 21 13
Brown 24 24 48 21
Green 1 7 7 1
Hazel 4 2 4 1
Le tableau de contingence permet d’estimer la loi jointe du couple variables (X,Y):
P(X= l_i , Y = m_j) = \frac{n_{ij}}{n}
La probabilité d’avoir les yeux bleus et les cheveux blonds peut être estimée par ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] 0.06
::: :::
A partir du tableau de contingence, on peut estimer les probabilités marginales, qui sont les probabilités des modalités:
La probabilité d’avoir les yeux bleus peut être estimée par ::: {.cell} ::: {.cell-output .cell-output-stdout}
[1] 0.28
::: :::
Ayant les loi marginales et jointes, il est aisée d’avoir les estimatations des probabilités conditionnelles
La probabilité d’avoir les yeux bleus sachant que l’on a les cheveux blonds peut être estimée par
[1] 0.2666667
Si les deux variables X et Y étaient indépendantes alors il suffirait des marges pour reconstruire le tableau.
Comme P(X= l_i , Y = m_j)= P(X= l_i) P( Y = m_j), on pourrait estimer la probabilité jointe P(X= l_i , Y = m_j) par
\frac{n_{i\bullet}}{n} \frac{n_{\bullet j}}{n}. et les n_{ij} théoriques seraient n P(X= l_i , Y = m_j) = \frac{n_{i\bullet}n_{\bullet j}}{n}
Le tableau mosaique vise à représenter un tableau de contingence avec des informations sur ses marges:
Si les deux variables X et Y sont indépendantes, les hauteurs des cases i \bullet sont toujours les mêmes (car proportionnelles à n_{i\bullet}).
Plus le diagramme mosaïque semble être traversé de lignes horizontales et plus l’hypothèse d’indépendance semble vraisemblable.
Pour aider le diagnostique, on peut ajouter de la couleur indiquant pour chaque case l’écart entre l’attendu et l’observé (résidus de Pearson)
d_{ij} = \frac{f_{ij} - e_{ij}}{\sqrt{e_{ij}}} avec
592 hommes et femmes dont la couleur des yeux et des cheveux a été notée ::: {.cell} ::: {.cell-output-display} ::: :::
Dans les diagrammes d’association chaque case est représentée par une base dont la hauteur (positive ou négative) est directement le résidu de Pearson correspondant